home *** CD-ROM | disk | FTP | other *** search
/ PC World 2006 December / PCWorld_2006-12_cd.bin / v cisle / ophcrack / ophcrack-win32-installer-2.3.3.exe / {app} / src / callbacks.c next >
C/C++ Source or Header  |  2006-10-11  |  43KB  |  1,352 lines

  1. /*
  2.  
  3.     Ophcrack is a Lanmanager/NTLM hash cracker based on the faster time-memory
  4.     trade-off using rainbow tables. 
  5.     
  6.     Created with the help of: Maxime Mueller, Luca Wullschleger, Claude
  7.     Hochreutiner, Andreas Huber and Etienne Dysli.
  8.  
  9.     Copyright 2006 Philippe Oechslin, Cedric Tissieres
  10.  
  11.     Ophcrack is free software; you can redistribute it and/or modify
  12.     it under the terms of the GNU General Public License as published by
  13.     the Free Software Foundation; either version 2 of the License, or
  14.     (at your option) any later version.
  15.  
  16.     Ophcrack is distributed in the hope that it will be useful,
  17.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.     GNU General Public License for more details.
  20.  
  21.     You should have received a copy of the GNU General Public License
  22.     along with Ophcrack; if not, write to the Free Software
  23.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  24.  
  25.     This program is released under the GPL with the additional exemption 
  26.     that compiling, linking, and/or using OpenSSL is allowed.
  27. */
  28.  
  29. /* Callbacks functions for the GUI */
  30.  
  31. /* 
  32.  * $Log: callbacks.c,v $
  33.  * Revision 2.3.3 2006/10/11 tissieres
  34.  * bkhive2, save tables directory, error msg when no tables
  35.  *
  36.  * Revision 2.3.2 2006/10/10 tissieres
  37.  * New pwdump6 version, fixed display bug, fixed bkhive bug
  38.  *
  39.  * Revision 2.3  2006/07/21 tissieres oechslin
  40.  * Help added, pwdump6 support, tables management, statusbar changed
  41.  *
  42.  * Revision 2.2  2006/03/20 tissieres
  43.  * Tables management improved
  44.  *
  45.  * Revision 2.1  2005/12/06 tissieres
  46.  * Added tables function
  47.  *
  48.  * Revision 2.0  2005/03/24  tissieres
  49.  * Initial revision
  50.  *
  51.  */
  52.  
  53.  
  54. #ifdef HAVE_CONFIG_H
  55. #  include <config.h>
  56. #endif
  57.  
  58. #include <gtk/gtk.h>
  59. #ifndef WIN32
  60. #include <sys/times.h>
  61. #else /* WIN32 */
  62. #include <sys/time.h>
  63. #include <windows.h>
  64. #endif /* WIN32 */
  65. #include <stdio.h>
  66. #include <stdlib.h>
  67. #include <unistd.h>
  68.  
  69. #include "callbacks.h"
  70. #include "interface.h"
  71. #include "support.h"
  72. #include "ophcrack.h"
  73.  
  74. extern GtkWidget *main_window;
  75. GtkWidget* fs;
  76. GtkWidget* popup_menu;
  77. GtkWidget* remote_dialog;
  78. GtkWidget* fc;
  79. GtkWidget* fc2;
  80. GtkCellRenderer     *renderer;
  81. GtkListStore *list_store;
  82. GtkListStore *list_store2;
  83. GtkWidget* about_window;
  84. GtkWidget* ts;
  85. GtkWidget* table_dialog;
  86. GtkWidget* load_hash_dialog;
  87. GtkWidget* readahead_window;
  88. GtkWidget* help_window;
  89.  
  90. extern char directory[128];
  91. extern int cols;
  92. extern int batch_tables;
  93. extern int offset;
  94. extern int last_table;
  95. extern int table_type;
  96. extern int chkpt1;
  97. extern int chkpt2;
  98.  
  99. int fill_tree(void);
  100. void clear_buffer(void);
  101. void hash_delete(void);
  102.  
  103. void
  104. on_load_file1_activate                 (GtkMenuItem     *menuitem,
  105.                                         gpointer         user_data)
  106. {
  107.   fs = create_fileselection();
  108.   gtk_widget_show(fs);
  109.   gtk_widget_set_sensitive(main_window, 0);
  110.   
  111. }
  112.  
  113.  
  114. void
  115. on_launch1_toggled                     (GtkToggleToolButton *toggletoolbutton,
  116.                                         gpointer         user_data)
  117. {
  118.   extern int STOP;
  119.   extern int batch_tables;
  120.   GtkWidget* tmp_image;
  121.   GtkWidget *toolbar1;
  122.   GtkIconSize tmp_toolbar_icon_size;
  123.   GtkWidget *tmp;
  124.   
  125.   toolbar1 = lookup_widget (GTK_WIDGET(user_data), "toolbar1");
  126.   tmp_toolbar_icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar1));
  127.   
  128.   if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(user_data))) {
  129.     gtk_tool_button_set_label(GTK_TOOL_BUTTON(user_data), "Stop");
  130.     tmp_image = gtk_image_new_from_stock ("gtk-stop", tmp_toolbar_icon_size);
  131.     gtk_widget_show (tmp_image);
  132.     gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (user_data), tmp_image);
  133.     STOP = 0;
  134.  
  135.     tmp = lookup_widget(main_window, "dump1");
  136.     gtk_widget_set_sensitive(tmp, 0);
  137.     tmp = lookup_widget(main_window, "deletebutton");
  138.     gtk_widget_set_sensitive(tmp, 0);
  139.     tmp = lookup_widget(main_window, "save_button");
  140.     gtk_widget_set_sensitive(tmp, 0);
  141.     tmp = lookup_widget(main_window, "exit1");
  142.     gtk_widget_set_sensitive(tmp, 0);
  143.     tmp = lookup_widget(main_window, "tablebutton");
  144.     gtk_widget_set_sensitive(tmp, 0);
  145.  
  146.     //    clear_buffer();
  147.     if (main_cmd() == -2) {
  148.       GtkWidget* error_dialog = create_dialog1();
  149.       gtk_window_set_title (GTK_WINDOW (error_dialog), "Tables not found");
  150.       tmp = lookup_widget(error_dialog, "label3");
  151.       gtk_label_set_text(GTK_LABEL(tmp), "Error: Select tables directory first!");
  152.       gtk_widget_show(error_dialog);
  153.     }
  154.       
  155.     fill_tree();
  156.     gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON (user_data), 0);
  157.     
  158.     tmp = lookup_widget(main_window, "dump1");
  159.     gtk_widget_set_sensitive(tmp, 1);
  160.     tmp = lookup_widget(main_window, "deletebutton");
  161.     gtk_widget_set_sensitive(tmp, 1);
  162.     tmp = lookup_widget(main_window, "save_button");
  163.     gtk_widget_set_sensitive(tmp, 1);
  164.     tmp = lookup_widget(main_window, "exit1");
  165.     gtk_widget_set_sensitive(tmp, 1);
  166.     tmp = lookup_widget(main_window, "tablebutton");
  167.     gtk_widget_set_sensitive(tmp, 1);
  168.   }
  169.   else {
  170.     gtk_tool_button_set_label(GTK_TOOL_BUTTON(user_data), "Launch");
  171.     tmp_image = gtk_image_new_from_stock ("gtk-execute", tmp_toolbar_icon_size);
  172.     gtk_widget_show (tmp_image);
  173.     gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (user_data), tmp_image);
  174.     STOP = 1;
  175.     
  176.     tmp = lookup_widget(main_window, "dump1");
  177.     gtk_widget_set_sensitive(tmp, 1);
  178.     tmp = lookup_widget(main_window, "deletebutton");
  179.     gtk_widget_set_sensitive(tmp, 1);
  180.     tmp = lookup_widget(main_window, "save_button");
  181.     gtk_widget_set_sensitive(tmp, 1);
  182.     tmp = lookup_widget(main_window, "exit1");
  183.     gtk_widget_set_sensitive(tmp, 1);
  184.     tmp = lookup_widget(main_window, "tablebutton");
  185.     gtk_widget_set_sensitive(tmp, 1);    
  186.    
  187.   }
  188. }
  189.  
  190. void
  191. on_exit1_activate                      (GtkMenuItem     *menuitem,
  192.                     gpointer         user_data)
  193. {
  194.   gtk_main_quit();
  195.   exit(0);
  196. }
  197.  
  198.  
  199. void
  200. on_ok_button1_clicked                  (GtkButton       *button,
  201.                                         gpointer         user_data)
  202. {
  203.   extern hashes;
  204.   GtkWidget *tmp;
  205.   
  206.   //char filename[200];
  207.   //sprintf(filename, "%s\0", gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fc)));
  208.   if (read_file(gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fs)))) {
  209.     
  210.     fill_tree();
  211.     gtk_widget_destroy(fs);
  212.     gtk_widget_set_sensitive(main_window, 1);
  213.     tmp = lookup_widget(main_window, "launch1");
  214.     gtk_widget_set_sensitive(tmp, 1);
  215.     tmp = lookup_widget(main_window, "save_button");
  216.     gtk_widget_set_sensitive(tmp, 1);
  217.     
  218.   }
  219.   else {
  220.     GtkWidget* error_dialog = create_dialog1();
  221.     gtk_widget_show(error_dialog);
  222.   }
  223. }
  224.  
  225.  
  226. void create_model(void) {
  227.   
  228.   
  229.   GtkTreeViewColumn   *col;
  230.   GtkWidget *hash_list;
  231.   
  232.   list_store = gtk_list_store_new (5, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
  233.   hash_list = lookup_widget (main_window, "hash_list");
  234.   
  235.   gtk_tree_view_set_model(GTK_TREE_VIEW(hash_list), GTK_TREE_MODEL(list_store));
  236.  
  237.   //COLUMN 1
  238.   col = gtk_tree_view_column_new();
  239.   gtk_tree_view_column_set_title(col, "ID");
  240.   
  241.   /* pack tree view column into tree view */
  242.   gtk_tree_view_append_column(GTK_TREE_VIEW(hash_list), col);
  243.  
  244.   renderer = gtk_cell_renderer_text_new();
  245.  
  246.   /* pack cell renderer into tree view column */
  247.   gtk_tree_view_column_pack_start(col, renderer, TRUE);
  248.   
  249.   gtk_tree_view_column_add_attribute(col, renderer, "text", 0);
  250.  
  251.   //COLUMN 2
  252.   col = gtk_tree_view_column_new();
  253.   gtk_tree_view_column_set_title(col, "USERNAME/LMHASH");
  254.  
  255.   /* pack tree view column into tree view */
  256.   gtk_tree_view_append_column(GTK_TREE_VIEW(hash_list), col);
  257.  
  258.   renderer = gtk_cell_renderer_text_new();
  259.  
  260.   /* pack cell renderer into tree view column */
  261.   gtk_tree_view_column_pack_start(col, renderer, TRUE);
  262.  
  263.   gtk_tree_view_column_add_attribute(col, renderer, "text", 1);
  264.  
  265.   //COLUMN 3
  266.   col = gtk_tree_view_column_new();
  267.   gtk_tree_view_column_set_title(col, "LMpasswd1");
  268.  
  269.   /* pack tree view column into tree view */
  270.   gtk_tree_view_append_column(GTK_TREE_VIEW(hash_list), col);
  271.  
  272.   renderer = gtk_cell_renderer_text_new();
  273.  
  274.   /* pack cell renderer into tree view column */
  275.   gtk_tree_view_column_pack_start(col, renderer, TRUE);
  276.  
  277.   gtk_tree_view_column_add_attribute(col, renderer, "text", 2);
  278.  
  279.   //COLUMN 4
  280.   col = gtk_tree_view_column_new();
  281.   gtk_tree_view_column_set_title(col, "LMpasswd2");
  282.  
  283.   /* pack tree view column into tree view */
  284.   gtk_tree_view_append_column(GTK_TREE_VIEW(hash_list), col);
  285.  
  286.   renderer = gtk_cell_renderer_text_new();
  287.  
  288.   /* pack cell renderer into tree view column */
  289.   gtk_tree_view_column_pack_start(col, renderer, TRUE);
  290.   
  291.   gtk_tree_view_column_add_attribute(col, renderer, "text", 3);
  292.  
  293.  
  294.   //COLUMN 5
  295.   col = gtk_tree_view_column_new();
  296.   gtk_tree_view_column_set_title(col, "NTpasswd");
  297.  
  298.   /* pack tree view column into tree view */
  299.   gtk_tree_view_append_column(GTK_TREE_VIEW(hash_list), col);
  300.  
  301.   renderer = gtk_cell_renderer_text_new();
  302.  
  303.   /* pack cell renderer into tree view column */
  304.   gtk_tree_view_column_pack_start(col, renderer, TRUE);
  305.  
  306.   gtk_tree_view_column_add_attribute(col, renderer, "text", 4);
  307.  
  308. }
  309.  
  310. int change_tree(int hash) {
  311.   GtkWidget *hash_list;
  312.   GtkTreeIter iter;
  313.   gsize j;
  314.   char temp[50];
  315.   char line[6] = {0};
  316.   
  317.   extern char info[MAX_HASH+1][64], password[MAX_HASH+1][16], 
  318.     password1[MAX_HASH+1][8], password2[MAX_HASH+1][8];
  319.   extern unsigned char lm_hash1[MAX_HASH+1][8], 
  320.     lm_hash2[MAX_HASH+1][8],
  321.     nt_hash[MAX_HASH+1][16]; 
  322.   extern int hashes, userid[MAX_HASH+1];  
  323.  
  324.   sprintf(line, "%d", hash);
  325.   gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(list_store), &iter, line);
  326.  
  327.   if (info[hash][0])
  328.     if (nt_hash[hash][0])
  329.       gtk_list_store_set(list_store, &iter, 0, userid[hash], 1, g_locale_to_utf8(info[hash], -1, NULL, &j, NULL), 2, password1[hash], 3, password2[hash], 4, password[hash], -1);
  330.     else 
  331.       gtk_list_store_set(list_store, &iter, 0, userid[hash], 1, g_locale_to_utf8(info[hash], -1, NULL, &j, NULL), 2, password1[hash], 3, password2[hash], -1);
  332.   else {
  333.     for (j=0; j<8; j++) snprintf(temp+j*2,3,  "%02hhx",lm_hash1[hash][j]);
  334.     for (j=0; j<8; j++) snprintf(temp+(8+j)*2,3, "%02hhx",lm_hash2[hash][j]);
  335.     if (nt_hash[hash][0])
  336.       gtk_list_store_set(list_store, &iter, 0, hash, 1, temp, 2, password1[hash], 3, password2[hash], 4, password[hash], -1);
  337.     else
  338.       gtk_list_store_set(list_store, &iter, 0, hash, 1, temp, 2, password1[hash], 3, password2[hash], -1);
  339.   }
  340.   return 1;
  341. }
  342.  
  343.  
  344. int fill_tree(void) {
  345.   int i;
  346.   gsize j;
  347.   GtkTreeIter   iter;
  348.   char temp[50];
  349.  
  350.   extern char info[MAX_HASH+1][64], password[MAX_HASH+1][16], 
  351.     password1[MAX_HASH+1][8], password2[MAX_HASH+1][8];
  352.   extern unsigned char lm_hash1[MAX_HASH+1][8], 
  353.     lm_hash2[MAX_HASH+1][8],
  354.     nt_hash[MAX_HASH+1][16]; 
  355.   extern int hashes, userid[MAX_HASH+1];
  356.  
  357.   gtk_list_store_clear(list_store);
  358.   
  359.   for (i=0; i<hashes; i++) {
  360.  
  361.     /* Append an empty row to the list store. Iter will point to the new row */
  362.     gtk_list_store_append(list_store, &iter);
  363.  
  364.     if (info[i][0])
  365.       if (nt_hash[i][0])
  366.     gtk_list_store_set(list_store, &iter, 0, userid[i], 1, g_locale_to_utf8(info[i], -1, NULL, &j, NULL), 2, password1[i], 3, password2[i], 4, password[i], -1);
  367.       else 
  368.     gtk_list_store_set(list_store, &iter, 0, userid[i], 1, g_locale_to_utf8(info[i], -1, NULL, &j, NULL), 2, password1[i], 3, password2[i], -1);
  369.     else {
  370.       for (j=0; j<8; j++) snprintf(temp+j*2,3,  "%02hhx",lm_hash1[i][j]);
  371.       for (j=0; j<8; j++) snprintf(temp+(8+j)*2,3, "%02hhx",lm_hash2[i][j]);
  372.       if (nt_hash[i][0])
  373.     gtk_list_store_set(list_store, &iter, 0, i, 1, temp, 2, password1[i], 3, password2[i], 4, password[i], -1);
  374.       else
  375.     gtk_list_store_set(list_store, &iter, 0, i, 1, temp, 2, password1[i], 3, password2[i], -1);
  376.     }
  377.   }
  378.   return 1;
  379. }
  380.  
  381. void clear_buffer(void) {
  382.   GtkWidget * textview1;
  383.   GtkTextBuffer* stats;  
  384.   GtkTextIter *start, *end;
  385.  
  386.   textview1 = lookup_widget(main_window, "textview1");
  387.   stats = gtk_text_view_get_buffer (GTK_TEXT_VIEW(textview1));
  388.   gtk_text_buffer_get_bounds(stats, start, end);
  389.   gtk_text_buffer_delete(stats, start, end);
  390.  
  391. }
  392.  
  393. void print_stats(void) {
  394.   extern int n_search,
  395.     n_fseek,
  396.     n_hashredux,
  397.     n_false,
  398.     n_false_redux,
  399.     n_match,
  400.     n_loop,
  401.     n_found;
  402.   
  403.   extern struct tms n_times;
  404.   extern int ticks;
  405.   extern clock_t n_start_time, laps_time; 
  406.   
  407.   
  408.   char tmp[200];
  409.   GtkTextBuffer* stats;
  410.   GtkWidget * textview1;
  411.   textview1 = lookup_widget(main_window, "textview1");
  412.   GtkTextIter iter;
  413.   stats = gtk_text_buffer_new(NULL);
  414.   gtk_text_view_set_buffer (GTK_TEXT_VIEW(textview1), stats);
  415.   gtk_text_buffer_get_iter_at_offset(stats, &iter, -1);
  416.  
  417.  
  418.   clock_t t;
  419.   
  420. #ifndef WIN32
  421.   t = times(&n_times);
  422. #else /* WIN32 */
  423.   t = clock();
  424. #endif /* WIN32 */
  425.   
  426.   sprintf(tmp, "Statistics: \n hash-redux calculations: %d\n",
  427.       n_hashredux);
  428.   gtk_text_buffer_insert(stats,&iter, tmp, -1);
  429.   sprintf(tmp," endpoint searched %d\n fseek operations %d\n",
  430.      n_search, n_fseek);
  431.   gtk_text_buffer_insert(stats,&iter, tmp, -1);
  432.   sprintf(tmp," matches found %d\n false alarms %d\n",
  433.      n_match,
  434.      n_false);
  435.   gtk_text_buffer_insert(stats,&iter, tmp, -1);
  436.   sprintf(tmp," hash-redux operations per false alarms %d\n",
  437.      (n_false? n_false_redux/n_false: 0));
  438.   gtk_text_buffer_insert(stats,&iter, tmp, -1);
  439.   sprintf(tmp," time elapsed %5.2fs\n\n", 
  440.      (float)(t-n_start_time)/ ticks );
  441.   gtk_text_buffer_insert(stats,&iter, tmp, -1);
  442. }
  443.  
  444.  
  445.   void update_statusbar(int k)
  446.    {
  447.      extern clock_t n_start_time, laps_time; 
  448.   extern struct tms n_times;  
  449.   extern int first_table, last_table, cols, n_found, hashes, ticks;
  450.  
  451.   GtkWidget * status_bar;
  452.   gint context_id;
  453.   gchar *buff;
  454.   gchar buff2[50]={0};
  455.  
  456.   switch(table_type) {
  457.   case 0:
  458.   case 1:
  459.     sprintf(buff2, "LM alphanum");
  460.     break;
  461.   case 2:
  462.     sprintf(buff2, "LM extended");
  463.     break;
  464.   case 3:
  465.     sprintf(buff2, "NT mixed");
  466.     break;
  467.   }
  468.  
  469.   status_bar = lookup_widget(GTK_WIDGET(main_window), "statusbar1");
  470.   context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR(status_bar), "");
  471.  
  472. #ifndef WIN32
  473.   laps_time = times(&n_times);
  474. #else /* WIN32 */
  475.   laps_time = clock();
  476. #endif /* WIN32 */
  477.  
  478.   buff = g_strdup_printf (" Table set: %s | Tables in use: %d to %d :%2d%% | Passwords:%d/%d | Time elapsed: %.2f", buff2, first_table+1, last_table+1, 100-(100*k)/cols, n_found, hashes, (float)(laps_time - n_start_time)/ticks);
  479.  
  480.   gtk_statusbar_push (GTK_STATUSBAR (status_bar), context_id, buff);
  481.   g_free (buff);
  482. }
  483.  
  484. void
  485. on_dump1_clicked                       (GtkToolButton   *toolbutton,
  486.                                         gpointer         user_data)
  487. {
  488.   int event_time;
  489.   GtkWidget *tmp;
  490.  
  491.   popup_menu = create_menu1();
  492.   event_time = gtk_get_current_event_time();
  493.  
  494. #ifndef WIN32 
  495.   tmp = lookup_widget(popup_menu, "local_pwdump1");
  496.   gtk_container_remove (GTK_CONTAINER (popup_menu), tmp);
  497.   tmp = lookup_widget(popup_menu, "remote_pwdump1");
  498.   gtk_container_remove (GTK_CONTAINER (popup_menu), tmp);
  499. #endif
  500.  
  501.   gtk_menu_popup(GTK_MENU(popup_menu), NULL, NULL, NULL, NULL, 0, event_time);
  502.  
  503. }
  504.  
  505.  
  506. void
  507. on_ok_button2_clicked                  (GtkButton       *button,
  508.                                         gpointer         user_data)
  509. {
  510.  
  511.   char *filename;
  512.   char command[500];
  513. #ifndef WIN32
  514.   char tmp_file[] = "/tmp/ophcrack.tmp";
  515.   char tmp_file2[] = "/tmp/ophcrack2.tmp";
  516. #else
  517.   char tmp_file[] = "ophcrack.tmp";
  518.   char tmp_file2[] = "ophcrack2.tmp";
  519. #endif  
  520.   GtkWidget *tmp;
  521.   
  522.   filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fc));
  523. #ifndef WIN32
  524.   sprintf(command, "bkhive2 \"%s/SYSTEM\" %s 2>&1 1>/dev/null", filename, tmp_file2);
  525.   system(command);
  526.   sprintf(command, "samdump2 \"%s/SAM\" %s > %s 2>/dev/null",  filename, tmp_file2, tmp_file);
  527. #else /* WIN32 */
  528.   sprintf(command, "..\\win32_tools\\bkhive2 \"%s\\SYSTEM\" %s", filename, tmp_file2);
  529.   system(command);
  530.   sprintf(command, "..\\win32_tools\\samdump2 \"%s\\SAM\" %s > %s",  filename, tmp_file2, tmp_file);
  531. #endif
  532.  
  533.   system(command);
  534.   if (read_file(tmp_file)) {
  535.     fill_tree();
  536.     unlink(tmp_file);
  537.     unlink(tmp_file2);
  538.  
  539.     gtk_widget_destroy(fc);
  540.  
  541.     gtk_widget_set_sensitive(main_window, 1);
  542.     tmp = lookup_widget(main_window, "launch1");
  543.     gtk_widget_set_sensitive(tmp, 1);
  544.     tmp = lookup_widget(main_window, "save_button");
  545.     gtk_widget_set_sensitive(tmp, 1);
  546.  
  547.   }
  548.   else {
  549.     unlink(tmp_file);
  550.     GtkWidget* error_dialog = create_dialog1();
  551.     gtk_widget_show(error_dialog);
  552.   }
  553. }
  554.  
  555.  
  556.  
  557. void
  558. on_save_ok_button_clicked              (GtkButton   *button,
  559.                                         gpointer         user_data)
  560. {
  561.   extern char info[MAX_HASH+1][64], password[MAX_HASH+1][16], 
  562.     password1[MAX_HASH+1][8], password2[MAX_HASH+1][8];
  563.   extern unsigned char lm_hash1[MAX_HASH+1][8], 
  564.     lm_hash2[MAX_HASH+1][8],
  565.     nt_hash[MAX_HASH+1][16]; 
  566.   extern int hashes, userid[MAX_HASH+1];
  567.   
  568.  
  569.   int i,h;
  570.   char *filename;
  571.   FILE *save_file;
  572.   unsigned char *tmp;
  573.  
  574.   filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fc2));
  575.   if (access(filename, F_OK) == 0)
  576.     unlink(filename);
  577.  
  578.   save_file = fopen(filename, "w");
  579.  
  580.   for (h=0; h<hashes; h++) {
  581.  
  582.     if (info[h][0])
  583.       fprintf(save_file,"%s",info[h]);
  584.     fprintf(save_file,":");
  585.     if (userid[h])
  586.       fprintf(save_file,"%d", userid[h]);
  587.     fprintf(save_file, ":");
  588.     for (i=0; i<8; i++) fprintf(save_file,"%02hhx",lm_hash1[h][i]);
  589.     for (i=0; i<8; i++) fprintf(save_file,"%02hhx",lm_hash2[h][i]);
  590.     fprintf(save_file,":");
  591.     if (strcmp(nt_hash[h],""))
  592.       for (i=0; i<16; i++) fprintf(save_file,"%02hhx",nt_hash[h][i]);
  593.     fprintf(save_file,":");
  594.     /* thanks to BaLP */
  595.     for (tmp = (unsigned char *)password1[h]; *tmp && (*tmp == ':' ? 
  596.       fprintf(save_file, "%c", 193) : fprintf(save_file, "%c", *tmp)); tmp++);
  597.     fprintf(save_file,":");
  598.     for (tmp = (unsigned char *)password2[h]; *tmp && (*tmp == ':' ? 
  599.       fprintf(save_file, "%c", 193) : fprintf(save_file, "%c", *tmp)); tmp++);
  600.     fprintf(save_file,":");
  601.     for (tmp = (unsigned char *)password[h]; *tmp && (*tmp == ':' ? 
  602.       fprintf(save_file, "%c", 193) : fprintf(save_file, "%c", *tmp)); tmp++);
  603.     fprintf(save_file, "\n");
  604.   }
  605.   fclose(save_file);
  606.   gtk_widget_destroy(fc2);
  607. }
  608.  
  609.  
  610. void
  611. on_save_button_clicked                  (GtkToolButton   *toolbutton,
  612.                                         gpointer         user_data)
  613. {
  614.   char current_dir[200];
  615.    
  616.   fc2 = create_filechooserdialog2();
  617.   getcwd(current_dir, 200);
  618.   gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc2), current_dir);
  619.   gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(fc2), "save.oph");
  620.   gtk_widget_show(fc2);
  621.   gtk_widget_set_sensitive(main_window, 0);
  622. }
  623.  
  624. void
  625. on_cancel_button1_clicked              (GtkButton       *button,
  626.                                         gpointer         user_data)
  627. {
  628.   gtk_widget_destroy(fs);
  629.   gtk_widget_set_sensitive(main_window, 1);
  630.  
  631. }
  632.  
  633. void
  634. on_cancel_button2_clicked              (GtkButton       *button,
  635.                                         gpointer         user_data)
  636. {
  637.   gtk_widget_destroy(fc);
  638.   gtk_widget_set_sensitive(main_window, 1);
  639. }
  640.  
  641.  
  642. void
  643. on_about_button_clicked                (GtkToolButton   *toolbutton,
  644.                                         gpointer         user_data)
  645. {
  646.   GdkColor blank = {0, 65535, 65535, 65535};
  647.   gint x, y, pwidth, pheight, width, height;
  648.   GtkWidget *temp;
  649.  
  650.   gtk_widget_set_sensitive(main_window, 0);
  651.   about_window = create_about_window();
  652.   temp = lookup_widget(about_window, "about_close_button");
  653.   gtk_widget_modify_bg(GTK_WIDGET(about_window), GTK_STATE_NORMAL, &blank);
  654.   gtk_widget_modify_bg(temp, GTK_STATE_PRELIGHT, &blank);
  655.   temp = lookup_widget(about_window, "about_text");
  656.   gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW(temp), 0);
  657.   gtk_window_set_decorated(GTK_WINDOW(about_window), FALSE);
  658.  
  659.   gtk_window_get_position(GTK_WINDOW(main_window), &x, &y);
  660.   gtk_window_get_size(GTK_WINDOW(main_window), &pwidth, &pheight);
  661.   gtk_window_get_size(GTK_WINDOW(about_window), &width, &height);
  662.  
  663.   x = (pwidth - width) / 2 + x;
  664.   y = (pheight - height) / 2 + y;
  665.  
  666.   gtk_widget_show(about_window);
  667.   gtk_window_move(GTK_WINDOW(about_window), x, y);
  668.  
  669.   
  670. }
  671.  
  672. void
  673. on_about_close_button_clicked          (GtkButton       *button,
  674.                                         gpointer         user_data)
  675. {
  676.   gtk_widget_destroy(about_window);
  677.   gtk_widget_set_sensitive(main_window, 1);
  678.   
  679. }
  680.  
  681. void
  682. on_from__sam_activate                   (GtkMenuItem     *menuitem,
  683.                                         gpointer         user_data)
  684. {
  685.   fc = create_filechooserdialog1();
  686.   gtk_widget_show(fc);
  687.   gtk_widget_set_sensitive(main_window, 0);
  688. }
  689.  
  690.  
  691. void
  692. on_local_pwdump1_activate              (GtkMenuItem     *menuitem,
  693.                                         gpointer         user_data)
  694. {
  695. #ifdef WIN32
  696.   FILE *tmpfile, *tmpfile2;
  697.   char command[500];
  698.   char tmp_file[] = "ophcrack.tmp";
  699.   char buff[100];
  700.   int n;
  701.   GtkWidget *tmp;
  702.  
  703.   SetCurrentDirectory("..\\win32_tools");
  704.   sprintf(command, "pwdump6.exe -o %s 127.0.0.1", tmp_file);
  705.   //tmpfile = popen(command, "r");
  706.   //tmpfile2 = fopen(tmp_file, "w");
  707.   system(command);
  708.   /*while ((n = fread(buff, 1, 100, tmpfile)))
  709.     fwrite(buff, 1, n, tmpfile2);
  710.   
  711.   pclose(tmpfile);
  712.   fclose(tmpfile2);
  713.   */
  714.   if (read_file(tmp_file)) {
  715.     fill_tree();
  716.     unlink(tmp_file);
  717.  
  718.     SetCurrentDirectory("..\\win32");
  719.     tmp = lookup_widget(main_window, "launch1");
  720.     gtk_widget_set_sensitive(tmp, 1);
  721.     tmp = lookup_widget(main_window, "save_button");
  722.     gtk_widget_set_sensitive(tmp, 1);
  723.   }
  724.   else {
  725.     unlink(tmp_file);
  726.     GtkWidget* error_dialog = create_dialog1();
  727.     gtk_widget_show(error_dialog);
  728.   }
  729. #endif
  730. }
  731.  
  732.  
  733. void
  734. on_remote_pwdump1_activate             (GtkMenuItem     *menuitem,
  735.                                         gpointer         user_data)
  736. {
  737. #ifdef WIN32
  738.   GtkWidget* tmp;
  739.   remote_dialog = create_dialog_remote_dump();
  740.   gtk_widget_show(remote_dialog);
  741.   tmp = lookup_widget(remote_dialog, "target_share");
  742.   gtk_entry_set_text(GTK_ENTRY(tmp), "admin$");
  743.   gtk_widget_set_sensitive(main_window, 0);
  744. #endif
  745.  
  746. }
  747.  
  748. void
  749. on_remote_cancel_button_clicked        (GtkButton       *button,
  750.                                         gpointer         user_data)
  751. {
  752. #ifdef WIN32
  753.   gtk_widget_destroy(remote_dialog);
  754.   gtk_widget_set_sensitive(main_window, 1);
  755. #endif
  756. }
  757.  
  758.  
  759. void
  760. on_remote_ok_button_clicked            (GtkButton       *button,
  761.                                         gpointer         user_data)
  762. {
  763. #ifdef WIN32
  764.   char command[500];
  765.   char tmp_file[] = "ophcrack.tmp";
  766.   char hostname[100];
  767.   char share[100];
  768.   char user[100];
  769.   int n, other_user = 0;
  770.   GtkWidget *tmp;
  771.  
  772.   tmp = lookup_widget(remote_dialog, "target_hostname");
  773.   sprintf(hostname,"%s", gtk_entry_get_text(GTK_ENTRY(tmp)));
  774.   if (!strcmp(hostname, "")) {
  775.     GtkWidget *error_dialog3 = create_dialog3();
  776.     gtk_widget_show(error_dialog3);
  777.   }
  778.   else {
  779.   
  780.     tmp = lookup_widget(remote_dialog, "target_share");
  781.     sprintf(share ,"%s",gtk_entry_get_text(GTK_ENTRY(tmp)));
  782.     if (strcmp(user, ""))
  783.       sprintf(share, "admin$");
  784.     
  785.     tmp = lookup_widget(remote_dialog, "target_user");
  786.     sprintf(user,"%s",gtk_entry_get_text(GTK_ENTRY(tmp)));
  787.     if (strcmp(user, "")) 
  788.       other_user=1;
  789.     
  790.  
  791.     if (other_user)
  792.       sprintf(command, "..\\win32_tools\\pwdump6.exe -o %s -u %s -s %s %s", tmp_file, user, share, hostname);
  793.     else
  794.       sprintf(command, "..\\win32_tools\\pwdump6.exe -o %s -s %s %s", hostname, tmp_file, share);
  795.  
  796.     system(command);
  797.     
  798.     if (read_file(tmp_file)) {
  799.       fill_tree();
  800.       unlink(tmp_file);
  801.       
  802.       gtk_widget_destroy(remote_dialog);
  803.       gtk_widget_set_sensitive(main_window, 1);
  804.       tmp = lookup_widget(main_window, "launch1");
  805.       gtk_widget_set_sensitive(tmp, 1);
  806.       tmp = lookup_widget(main_window, "save_button");
  807.       gtk_widget_set_sensitive(tmp, 1);
  808.     }
  809.     else {
  810.       unlink(tmp_file);
  811.       GtkWidget* error_dialog = create_dialog1();
  812.       gtk_widget_show(error_dialog);
  813.     }
  814.   }
  815. #endif
  816. }
  817.  
  818.  
  819. void
  820. on_dialog_remote_dump_close            (GtkDialog       *dialog,
  821.                                         gpointer         user_data)
  822. {
  823. #ifdef WIN32
  824.   gtk_widget_destroy(remote_dialog);
  825.   gtk_widget_set_sensitive(main_window, 1);
  826. #endif
  827. }
  828.  
  829.  
  830. void
  831. on_filechooserdialog1_close            (GtkDialog       *dialog,
  832.                                         gpointer         user_data)
  833. {
  834.   gtk_widget_destroy(fc);
  835.   gtk_widget_set_sensitive(main_window, 1);
  836.  
  837. }
  838.  
  839.  
  840. void
  841. on_filechooserdialog2_close            (GtkDialog       *dialog,
  842.                                         gpointer         user_data)
  843. {
  844.  
  845.   gtk_widget_destroy(fc2);
  846.   gtk_widget_set_sensitive(main_window, 1);
  847.  
  848.  
  849. }
  850.  
  851.  
  852. void
  853. on_fileselection_close                 (GtkDialog       *dialog,
  854.                                         gpointer         user_data)
  855. {
  856.   gtk_widget_destroy(fs);
  857.   gtk_widget_set_sensitive(main_window, 1);
  858.  
  859. }
  860.  
  861.  
  862. void
  863. on_tablebutton_activate                (GtkToolButton   *toolbutton,
  864.                                         gpointer         user_data)
  865. {
  866.   GtkWidget *tmp;
  867.   GtkCellRenderer *renderer2;
  868.   GtkTreeViewColumn *col;
  869.   GtkTreeIter iter;
  870.   char buf[5];
  871.  
  872.   table_dialog = create_table_dialog();
  873.   gtk_widget_show(table_dialog);
  874.   gtk_widget_set_sensitive(main_window, 0);
  875.  
  876.   tmp = lookup_widget(table_dialog, "entry_directory");
  877.   if (strcmp(directory, "") !=0)
  878.     gtk_entry_set_text(GTK_ENTRY(tmp), directory);
  879.  
  880.   tmp = lookup_widget(table_dialog, "table_type_list");
  881.   list_store2 = gtk_list_store_new (1, G_TYPE_STRING);
  882.   
  883.   gtk_tree_view_set_model(GTK_TREE_VIEW(tmp), GTK_TREE_MODEL(list_store2));
  884.   col = gtk_tree_view_column_new();
  885.   gtk_tree_view_column_set_title(col, "ID");
  886.   
  887.   /* pack tree view column into tree view */
  888.   gtk_tree_view_append_column(GTK_TREE_VIEW(tmp), col);
  889.  
  890.   renderer2 = gtk_cell_renderer_text_new();
  891.   gtk_tree_view_column_pack_start(col, renderer2, TRUE);
  892.   gtk_tree_view_column_add_attribute(col, renderer2, "text", 0);
  893.  
  894.   gtk_list_store_clear(list_store2);
  895.  
  896.   gtk_list_store_append(list_store2, &iter);
  897.   gtk_list_store_set(list_store2, &iter, 0, "LM: Alphanumeric SSTIC04-10k (388MB)", -1);
  898.   gtk_list_store_append(list_store2, &iter);
  899.   gtk_list_store_set(list_store2, &iter, 0, "LM: Alphanumeric SSTIC04-5k (720MB)", -1);
  900.   gtk_list_store_append(list_store2, &iter);
  901.   gtk_list_store_set(list_store2, &iter, 0, "LM: Extended (alphanum + 33 special)", -1);
  902.   gtk_list_store_append(list_store2, &iter);
  903.   gtk_list_store_set(list_store2, &iter, 0, "NT: (6 ext, 7 alphanum, 8 lowalpha-num)", -1);
  904.  
  905.   if (table_type >=0) {
  906.     sprintf(buf, "%d", table_type);
  907.     gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(list_store2), &iter, buf);
  908.     gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(tmp)), &iter);  
  909.   } else 
  910.     if (strcmp(directory, "") !=0) 
  911.       if (auto_detect_tables(directory)) {
  912.     tmp = lookup_widget(table_dialog, "entry_directory");
  913.     gtk_entry_set_position(GTK_ENTRY(tmp), -1);
  914.     
  915.     tmp = lookup_widget(table_dialog, "table_type_list");
  916.     sprintf(buf, "%d", table_type);
  917.     gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(list_store2), &iter, buf);
  918.     gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(tmp)), &iter);  
  919.       }
  920. }  
  921.  
  922.  
  923.  
  924. void
  925. on_table_dialog_destroy                (GtkObject       *object,
  926.                                         gpointer         user_data)
  927. {
  928.   gtk_widget_destroy(table_dialog);
  929.   gtk_widget_set_sensitive(main_window, 1);
  930.  
  931. }
  932.  
  933. void
  934. on_cancel_table_dialog_clicked         (GtkButton       *button,
  935.                                         gpointer         user_data)
  936. {
  937.   gtk_widget_destroy(table_dialog);
  938.   gtk_widget_set_sensitive(main_window, 1);
  939. }
  940.  
  941.  
  942. void
  943. on_ok_table_dialog_clicked             (GtkButton       *button,
  944.                                         gpointer         user_data)
  945. {
  946.   GtkWidget *tmp;
  947.   unsigned char filename[256];
  948.   extern int open_tables;
  949.   char *parameter;
  950.   FILE *configfile;
  951.   char config_filename[300];
  952.   
  953.   char *line = (char *)malloc(100*sizeof(char)); 
  954.  
  955.   tmp = lookup_widget(table_dialog, "entry_directory");
  956.   sprintf(directory, "%s", gtk_entry_get_text(GTK_ENTRY(tmp)));
  957.  
  958. #ifdef WIN32
  959.   sprintf(config_filename, "%s\\config.ini", g_win32_get_package_installation_directory (NULL, NULL));
  960. #else
  961.   sprintf(config_filename, "%s/%s/config.ini", PACKAGE_DATA_DIR, PACKAGE);
  962. #endif
  963.  
  964.   if ((configfile=fopen((char *)config_filename,"w"))) {
  965. #ifdef WIN32
  966.     fprintf(configfile, "table_dir=%s\n", gtk_entry_get_text(GTK_ENTRY(tmp)));
  967. #else
  968.     fprintf(configfile, "table_dir=%s\n", gtk_entry_get_text(GTK_ENTRY(tmp)));
  969. #endif
  970.     fclose(configfile);
  971.   }
  972.   
  973.   gtk_widget_destroy(table_dialog);
  974.   gtk_widget_set_sensitive(main_window, 1);
  975.   
  976.   open_tables=0;
  977.  
  978. }
  979.  
  980.  
  981. void
  982. on_button_directory_clicked            (GtkButton       *button,
  983.                                         gpointer         user_data)
  984. {
  985.  
  986.   ts = create_tableselection();
  987.   gtk_widget_show(ts);
  988.   gtk_widget_set_sensitive(table_dialog, 0);
  989.  
  990. }
  991.  
  992. void
  993. on_cancel_ts_clicked                   (GtkButton       *button,
  994.                                         gpointer         user_data)
  995. {
  996.   gtk_widget_destroy(ts);
  997.   gtk_widget_set_sensitive(main_window, 0);
  998.   gtk_widget_set_sensitive(table_dialog, 1);
  999.  
  1000. }
  1001.  
  1002.  
  1003. void
  1004. on_ok_ts_clicked                       (GtkButton       *button,
  1005.                                         gpointer         user_data)
  1006. {
  1007.   GtkWidget *tmp;
  1008.   char buf[5];
  1009.   GtkTreeIter iter;
  1010.  
  1011.   if (auto_detect_tables(gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (ts)))) {
  1012.     tmp = lookup_widget(table_dialog, "entry_directory");
  1013.     gtk_entry_set_text(GTK_ENTRY(tmp), gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (ts)));
  1014.     gtk_entry_set_position(GTK_ENTRY(tmp), -1);
  1015.     
  1016.     tmp = lookup_widget(table_dialog, "table_type_list");
  1017.     sprintf(buf, "%d", table_type);
  1018.     gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(list_store2), &iter, buf);
  1019.     gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(tmp)), &iter);  
  1020.   
  1021.     gtk_widget_destroy(ts);
  1022.     gtk_widget_set_sensitive(main_window, 0);
  1023.     gtk_widget_set_sensitive(table_dialog, 1);
  1024.     
  1025.   }
  1026.   else {
  1027.     GtkWidget* error_dialog = create_dialog1();
  1028.     gtk_window_set_title (GTK_WINDOW (error_dialog), "Tables not found");
  1029.     tmp = lookup_widget(error_dialog, "label3");
  1030.     gtk_label_set_text(GTK_LABEL(tmp), "Error: No known tables were found in the directory selected");
  1031.     gtk_widget_show(error_dialog);
  1032.   }
  1033.   
  1034. }
  1035.  
  1036.  
  1037. void
  1038. on_tableselection_close                (GtkObject       *object,
  1039.                                         gpointer         user_data)
  1040. {
  1041.   gtk_widget_destroy(ts);
  1042.   gtk_widget_set_sensitive(main_window, 1);
  1043. }
  1044.  
  1045. void hash_delete(void) {
  1046.   g_print("delete");
  1047. }
  1048.  
  1049.  
  1050. void
  1051. on_load_single_hash1_activate          (GtkMenuItem     *menuitem,
  1052.                                         gpointer         user_data)
  1053. {
  1054.   load_hash_dialog = create_load_hash_dialog();
  1055.   gtk_widget_show(load_hash_dialog);
  1056.   gtk_widget_set_sensitive(main_window, 0);
  1057.  
  1058. }
  1059.  
  1060.  
  1061. void
  1062. on_cancel_load_hash_dialog_clicked     (GtkButton       *button,
  1063.                                         gpointer         user_data)
  1064. {
  1065.   gtk_widget_destroy(load_hash_dialog);
  1066.   gtk_widget_set_sensitive(main_window, 1);
  1067.  
  1068. }
  1069.  
  1070.  
  1071. void
  1072. on_ok_load_hash_dialog_clicked         (GtkButton       *button,
  1073.                                         gpointer         user_data)
  1074. {
  1075.   char line[200];
  1076.   GtkWidget *tmp;
  1077.  
  1078.   tmp = lookup_widget(load_hash_dialog, "entry4");
  1079.   sprintf(line, "%s", gtk_entry_get_text(GTK_ENTRY(tmp)));
  1080.   if (read_line(line)) {
  1081.     fill_tree();
  1082.     tmp = lookup_widget(main_window, "launch1");
  1083.     gtk_widget_set_sensitive(tmp, 1);
  1084.  
  1085.     gtk_widget_destroy(load_hash_dialog);
  1086.     gtk_widget_set_sensitive(main_window, 1);
  1087.   }
  1088.   else {
  1089.     GtkWidget* error_dialog = create_dialog1();
  1090.     gtk_widget_show(error_dialog);
  1091.   }
  1092.  
  1093. }
  1094.  
  1095.  
  1096. void
  1097. on_load_hash_dialog_destroy            (GtkObject       *object,
  1098.                                         gpointer         user_data)
  1099. {
  1100.   gtk_widget_destroy(load_hash_dialog);
  1101.   gtk_widget_set_sensitive(main_window, 1);
  1102.  
  1103. }
  1104.  
  1105.  
  1106. void
  1107. on_deletebutton_clicked                (GtkToolButton   *toolbutton,
  1108.                                         gpointer         user_data)
  1109. {
  1110.   GtkWidget *hash_list;
  1111.   GtkTreeIter iter;
  1112.  
  1113.   hash_list = lookup_widget (main_window, "hash_list");
  1114.  
  1115.   if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(hash_list)),
  1116.                       NULL, &iter)) {
  1117.     remove_line(atoi(gtk_tree_model_get_string_from_iter (GTK_TREE_MODEL(list_store), &iter)));
  1118.     fill_tree();
  1119.   }
  1120. }
  1121.  
  1122. void
  1123. show_readahead_window(int num) {
  1124.   GtkWidget* tmp;
  1125.   char buf[50];
  1126.   gint x, y, pwidth, pheight, width, height;
  1127.  
  1128.   readahead_window = create_readahead_window();
  1129.   tmp = lookup_widget (readahead_window, "readahead_label");
  1130.   sprintf(buf, "Pre-loading table %d", num+1);
  1131.   gtk_label_set_text(GTK_LABEL(tmp), buf);
  1132.  
  1133.   gtk_window_get_position(GTK_WINDOW(main_window), &x, &y);
  1134.   gtk_window_get_size(GTK_WINDOW(main_window), &pwidth, &pheight);
  1135.   gtk_window_get_size(GTK_WINDOW(readahead_window), &width, &height);
  1136.  
  1137.   x = (pwidth - width) / 2 + x;
  1138.   y = (pheight - height) / 2 + y;
  1139.  
  1140.   gtk_widget_show(readahead_window);
  1141.   gtk_window_move(GTK_WINDOW(readahead_window), x, y);
  1142.  
  1143. }
  1144.  
  1145. void
  1146. show_clean_window(void) {
  1147.   GtkWidget* tmp;
  1148.   char buf[100];
  1149.   gint x, y, pwidth, pheight, width, height;
  1150.  
  1151.   readahead_window = create_readahead_window();
  1152.   tmp = lookup_widget (readahead_window, "readahead_label");
  1153.   sprintf(buf, "Trying to find place in RAM for the tables");
  1154.   gtk_label_set_text(GTK_LABEL(tmp), buf);
  1155.  
  1156.   gtk_window_get_position(GTK_WINDOW(main_window), &x, &y);
  1157.   gtk_window_get_size(GTK_WINDOW(main_window), &pwidth, &pheight);
  1158.   gtk_window_get_size(GTK_WINDOW(readahead_window), &width, &height);
  1159.  
  1160.   x = (pwidth - width) / 2 + x;
  1161.   y = (pheight - height) / 2 + y;
  1162.  
  1163.   gtk_widget_show(readahead_window);
  1164.   gtk_window_move(GTK_WINDOW(readahead_window), x, y);
  1165.  
  1166. }
  1167.  
  1168.  
  1169. void 
  1170. hide_readahead_window(void) {
  1171.   
  1172.   gtk_widget_destroy(readahead_window);
  1173.  
  1174. }
  1175.  
  1176. #ifdef LIVECD
  1177. void activate_launch_toggle (void) {
  1178.  
  1179.   GtkWidget *tmp;
  1180.   char tmp_file[] = "/tmp/ophcrack.tmp";
  1181.  
  1182.   if (read_file(tmp_file)) {
  1183.     fill_tree();
  1184.     
  1185.     gtk_widget_set_sensitive(main_window, 1);
  1186.     tmp = lookup_widget(main_window, "launch1");
  1187.     gtk_widget_set_sensitive(tmp, 1);
  1188.     tmp = lookup_widget(main_window, "save_button");
  1189.     gtk_widget_set_sensitive(tmp, 1);
  1190.     
  1191.   }
  1192.   tmp = lookup_widget(main_window, "launch1");
  1193.   gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(tmp), TRUE);
  1194.  
  1195. }
  1196. #endif
  1197.  
  1198.  
  1199. void
  1200. on_help_button_clicked                 (GtkToolButton   *toolbutton,
  1201.                                         gpointer         user_data)
  1202. {
  1203.   GtkWidget *tmp;
  1204.  
  1205.   gtk_widget_set_sensitive(main_window, 0);
  1206.   help_window = create_help_window();
  1207.  
  1208.   tmp = lookup_widget(help_window,"help_load");
  1209.   gtk_label_set_text(GTK_LABEL(tmp)," \
  1210. Use this button to load hashes into Ophcrack. You can chose from: \n \
  1211. \n \
  1212.    Single hash: to insert a single hash by hand into Ophcrack. \n \
  1213. \n \
  1214.    PWDUMP File: to import hashes from a file compatible with the \n \
  1215.                 format used by pwdump.  \n \
  1216. \n \
  1217.    From Encrypted SAM: Import hashes from the SYSTEM and the SAM files \n \
  1218.                 located in the System32 directory of Windows. Note \n \
  1219.                 that you can only access this files from a Windows \n \
  1220.                 partition that has not booted.  \n \
  1221. \n \
  1222.    From Local SAM: Loads the hashes from the SAM of Windows system \n \
  1223.                 on which Ophcrack is running. You must be an\n \
  1224.                 administrator of the system to be able to do this.\n \
  1225.                 This is obviously only available in the Windows  \n \
  1226.                 version of Ophcrack. \n \
  1227.  \n \
  1228.    From Remote SAM: Connects to a remote machine and retrieves the hashes \n \
  1229.                 from the SAM. You need to know the username and password \n \
  1230.                 of an administrator on the remote machine. You also need\n \
  1231.                 to know the name of a writable share on the remote machine.\n \
  1232.                 Only available in the Windows version of Ophcrack. \n \
  1233. \n \
  1234. ");
  1235.  
  1236.  tmp = lookup_widget(help_window,"help_delete");
  1237.   gtk_label_set_text(GTK_LABEL(tmp)," \
  1238. This button deletes the hash that is currently selected in the \n \
  1239. main window. Use this function to remove the hashes in wihch  \n \
  1240. you are not interested (e.g. the Guest account). This will \n \
  1241. accelerate the cracking of the remaining hashes. \n \
  1242. ");
  1243.  
  1244.   tmp = lookup_widget(help_window,"help_tables");
  1245.   gtk_label_set_text(GTK_LABEL(tmp)," \
  1246. This is where you select the set of rainbow tables you want to use. \n \
  1247. Following table sets are suported by this version of Ophcrack:\n \
  1248. \n \
  1249.    LM: Alphanumeric SSTIC04-10k: This is a small table set (388MB)\n \
  1250.                 which contains the LanManager hashes of 99.9% of all \n \
  1251.                 alphanumerical passwords. These are passwords made of \n \
  1252.                 mixed case letters and numbers (about 80 billion\n \
  1253.                 hashes). Because the LanManger hash cuts passwords\n \
  1254.                 into two pieces of 7 characters, passwords of length\n \
  1255.                 1 to 14 can be cracked with this table set. Since the\n \
  1256.                 LanManager hash is also not case sensitive, the 80 \n \
  1257.                 billion hashes in this table set corresponds to \n \
  1258.                 12 septillion (or 2^83) passwords. \n \
  1259. \n \
  1260.    LM: Alphanumeric SSTIC04-5k: This table set also covers 99.9% of \n \
  1261.                 the LanManager hashes of all alphanumerical passwords\n \
  1262.                 Because the tables are about twice as big (720MB) \n \
  1263.                 cracking is about four times faster, but only if  \n \
  1264.                 you have at least one GB of RAM.\n \
  1265. \n \
  1266.    LM: Extended (alphanum + 33 special): This set covers 96% of \n \
  1267.                 the LanManger hashes of passwords made of up to 14 \n \
  1268.                 mixed case letters, numbers and the following 33 \n \
  1269.                 special characters: !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|} ~\n \
  1270.                 There are about 7 trillion hashes in this table set\n \
  1271.                 covering 5 octillion (or 2^92) passwords\n \
  1272. \n \
  1273.    NT: (6 ext, 7 alphanum, 8 lowalpha-num): This set contains NT hahses\n \
  1274.                 You can use this table set to crack the hashes on \n \
  1275.                 machines where the LanManager hash has been disabled.\n \
  1276.                 The set contains 99.0% of the hashes of the passwords \n \
  1277.                 made of the following characters: \n \
  1278.                 - up to six mixed case letters, numbers and 33 special\n \
  1279.                   characters (same as above)  \n \
  1280.                 - seven mixed case letters and numbers \n \
  1281.                 - eight lowercase letters and numbers\n\n \
  1282.                 There are 7 trillion hashes in this table, corresponding\n \
  1283.                 to 7 trillion passwords (the NT hash does not suffer from\n \
  1284.                 the weaknesses of the LanManager). \n \
  1285. \n \
  1286. For most efficient cracking, start by deleting the hashes you do not \n \
  1287. want to crack. Then select an alphanumerical table set. Either the smaller\n \
  1288. one if you have 500MB or less of RAM or the larger one otherwise. Use the \n \
  1289. LM extented table set to crack the remaining hashes. If all LanManager \n \
  1290. hashes come up empty, the administrator has disabled them. Your only \n \
  1291. option is to use the NT table set. \n \
  1292. \n \
  1293. Note: the alphanumerical table sets are free and can be downloaded from \n \
  1294. the Internet. The other table sets can be ordered at \n \
  1295. http://www.objectif-securite.ch/ophcrack\n \
  1296. ");
  1297.  
  1298.  tmp = lookup_widget(help_window,"help_launch");
  1299.   gtk_label_set_text(GTK_LABEL(tmp)," \
  1300. The launch button starts the cracking process. Don't forget to select a\n \
  1301. table set before launching the attack. Once the cracking process is \n \
  1302. started, the button transforms into a stop button. \n \
  1303. \n \
  1304. If you stop and restart a cracking session the hashes that have already\n \
  1305. been cracked will not be cracked a second time. However, the look-up \n \
  1306. process for the remaining hashes will start again at the beginning of\n \
  1307. the first table. \n \
  1308. \n \
  1309. Ophcrack will preload parts of the tables into memory depending on their\n \
  1310. size and on the amount of available RAM. The more tables it can fit \n \
  1311. into the RAM, the faster will be the attack. Under Windows you \n \
  1312. may want to quit other applications before launching the attack, to leave \n \
  1313. more memory available to Ophcrack. \n \
  1314. \n \
  1315. There are four tables in each table set. Ophcrack will cylce throuhg\n \
  1316. all four tables (one by one, two by two or more depending on available \n \
  1317. memory until it finds all hashes or arrives at the end of the last table. \n \
  1318. The status bar at the bottom of the window displays which tables are \n \
  1319. currently used and how far the look-up is in these tables. \n \
  1320. ");
  1321.  
  1322.  tmp = lookup_widget(help_window,"help_save");
  1323.   gtk_label_set_text(GTK_LABEL(tmp)," \
  1324. Use the save button to save the current cracking session. The hases and \n \
  1325. the passwords that have already been cracked will be saved in a file\n \
  1326. in a format compatible with PWDUMP. You can later load the file using the\n \
  1327. \"PWDUMP File\" option of the Load button. \n\
  1328. ");
  1329.  
  1330.   gtk_widget_show(help_window);
  1331. }
  1332.  
  1333.  
  1334. void
  1335. on_help_window_close                   (GtkObject       *object,
  1336.                                         gpointer         user_data)
  1337. {
  1338.   gtk_widget_destroy(help_window);
  1339.   gtk_widget_set_sensitive(main_window, 1);
  1340. }
  1341.  
  1342. void show_error_max_hash() {
  1343.   GtkWidget *tmp;
  1344.  
  1345.   GtkWidget* error_dialog = create_dialog1();
  1346.   gtk_window_set_title (GTK_WINDOW (error_dialog), "Max number of hashes reached");
  1347.   tmp = lookup_widget(error_dialog, "label3");
  1348.   gtk_label_set_text(GTK_LABEL(tmp), "Warning: Only the first 35000 hashes have been loaded\nPlease split your hash file in several parts if you want to crack more than 35000 hashes.");
  1349.   gtk_widget_show(error_dialog);
  1350.  
  1351. }
  1352.